package cn.edu.zafu.bigdata.x.hzq;

abstract class Shape {
    // 抽象方法，用于计算形状的面积
    public abstract double area();

    // 抽象方法，用于计算形状的周长
    public abstract double perimeter();

    // final 方法，用于打印形状的类型、面积和周长
    public final void display() {
        System.out.println("Shape Type: " + this.getClass().getSimpleName());
        System.out.println("Area: " + area());
        System.out.println("Perimeter: " + perimeter());
    }
}
// Circle 类，继承自 Shape
class Circle extends Shape {
    // 属性 radius（半径）
    private double radius;

    // 构造函数
    public Circle(double radius) {
        this.radius = radius;
    }

    // 实现 area() 方法
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    // 实现 perimeter() 方法
    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

// Rectangle 类，继承自 Shape
class Rectangle extends Shape {
    // 属性 length（长度）和 width（宽度）
    private double length;
    private double width;

    // 构造函数
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // 实现 area() 方法
    @Override
    public double area() {
        return length * width;
    }

    // 实现 perimeter() 方法
    @Override
    public double perimeter() {
        return 2 * (length + width);
    }
}
class TestShape {
    public static void main(String[] args) {
        // 创建 Circle 和 Rectangle 的实例
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        // 调用每个实例的 display() 方法，验证 final 方法是否能被子类重写
        circle.display(); // 将打印 Circle 的类型、面积和周长
        rectangle.display(); // 将打印 Rectangle 的类型、面积和周长

        // 验证抽象类的工作原理以及强制子类实现的行为
        // 抽象类 Shape 强制 Circle 和 Rectangle 实现 area() 和 perimeter() 方法
    }
}
// 尝试创建一个 final 类，并观察该类是否能被继承
final class FinalClass {
    public void method() {
        System.out.println("This is a final class method.");
    }
}

// 尝试创建一个 final 方法，并观察该方法是否能被子类重写
class ParentClass {
    public final void method() {
        System.out.println("This is a final method in parent class.");
    }
}

class ChildClass extends ParentClass {
    // 这里不能重写 method() 方法，因为父类的该方法是 final 的
}

// 使用 final 关键字修饰一个变量，观察该变量的行为是否可以被修改
class FinalVariableExample {
    public final int value = 10; // final 变量，初始化后不能被修改

    public void modifyValue() {
        // value = 20; // 这将导致编译错误，因为 final 变量不能被重新赋值
    }
}

public class FinalUsageTest {
    public static void main(String[] args) {
        // 测试 final 类
        FinalClass finalClass = new FinalClass();
        finalClass.method();

        // 测试 final 方法
        ParentClass parentClass = new ParentClass();
        parentClass.method();

        // 测试 final 变量
        FinalVariableExample example = new FinalVariableExample();
        example.modifyValue(); // 尝试修改 final 变量，将导致编译错误
    }
}

